var _n66;
var cc__extends = __extends;
var cc__createBinding = __createBinding;
var cc__setModuleDefault = __setModuleDefault;
var cc__decorate = __decorate;
var cc__importStar = __importStar;
var cc__awaiter = __awaiter;
var cc__generator = __generator;
var cc__asyncValues = __asyncValues;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var cc_EventManager = require("EventManager");
var zqcc_eventManager = cc__importDefault(cc_EventManager);
var cc_GameEventType = require("GameEventType");
var cc_frameNamespace = require("zqcc_frameNamespace");
var zqcc_frameNameSpa = cc__importDefault(cc_frameNamespace);
var cc_gameMode_Json = require("gameMode_Json");
var cc_userService = require("userService");
var zqcc_userService = cc__importDefault(cc_userService);
var cc_OverallSystem = require("zqcc_OverallSystem");
var zqcc_overallSystm = cc__importStar(cc_OverallSystem);
var cc__decorator = cc._decorator;
var cc_ccp_ccclass = cc__decorator.ccclass;
var cc_ccp_property = cc__decorator.property;
var def_zqcc_loading = function (t) {
  function _ctor() {
    let result = (t !== null) && t.apply(this, arguments) || this; // 使用let代替var，更符合现代JavaScript风格

    // 初始化属性
    result.zqcc_totalBar = null;
    result.zqcc_onceBar = null;
    result.zqcc_lbLoad = null;
    result.zqcc_totalCnt = 0;
    result.zqcc_completedCnt = 0;
    result.zqcc_tishi = null;
    result.zqcc_kuaishouruanzhu = null;

    // 加载资产列表
    result.loadAssetList = [
      {
        bundleKey: zqcc_frameNameSpa.default.BundleName.loadingPage,
        name: "游戏加载页面"
      },
      {
        bundleKey: zqcc_frameNameSpa.default.BundleName.Sound,
        name: "游戏音频资源"
      }
    ];

    return result; // 返回最终的对象
  }
  cc__extends(_ctor, t);
  _ctor.prototype.onLoad = function () {
    // 检查平台并设置提示的活动状态
    if (cc.sys.platform === cc.sys.ANDROID || cc.sys.platform === cc.sys.VIVO_GAME) {
      this.zqcc_tishi.active = true; // 对于Android和VIVO游戏平台，激活提示
    }

    window.LookCnt = 0; // 初始化LookCnt为0

    // 根据不同的平台初始化SDK或调用Init方法
    if (cc.sys.platform === cc.sys.BYTEDANCE_GAME || cc.sys.platform === cc.sys.WECHAT_GAME) {
      this.zqcc_initSdk(); // 针对字节跳动和微信游戏平台初始化SDK
    } else {
      this.zqcc_Init(); // 其他平台调用Init方法
    }

    // 检查是否存在ks并激活快收入按钮
    if (window.ks) {
      this.zqcc_kuaishouruanzhu.active = true;
    }
  };
  _ctor.prototype.zqcc_initSdk = function () {
    return cc__awaiter(this, undefined, undefined, function () {
      let config; // 使用let更符合现代JavaScript风格
      return cc__generator(this, function () {
        config = {
          gid: "wx_dnwzqmx", // 默认的gid
          version: "1.0.0",  // 版本号
          tdAppKey: "3BA06AB4A4664B4ABE714DB0ED058E9C" // 应用密钥
        };

        // 如果window.tt存在，将gid修改为tt_jtdzzmx
        if (window.tt) {
          config.gid = "tt_jtdzzmx";
        }

        seeg.init(config); // 初始化seeg
        this.zqcc_login(); // 执行登录
        console.log("seeg init", config); // 打印初始化信息
        return [2]; // 返回结束标识
      });
    });
  };
  _ctor.prototype.zqcc_login = function () {
    let self = this; // 使用let提高作用域的可控性
    seeg.onLoginRet(function (response) {
      console.log("zqcc_login ret", response); // 打印登录返回信息
      window.SEEG_USER_INFO = response; // 将用户信息存储到全局变量
      self.zqcc_getRemoteConfig(); // 调用获取远程配置的方法
    });
  };
  _ctor.prototype.zqcc_getUserData = function () {
    let self = this; // 使用let提高作用域的可控性
    let localUserData = zqcc_overallSystm.sers().userSrv.getFeibiaoData(); // 获取本地用户数据

    seeg.getUserData(function (response) {
      cc.log("getuserdata", response); // 打印获取的用户数据

      if (!response.errCode) { // 检查是否有错误代码
        let serverLevel = response.data.level; // 从服务器响应中获取用户级别

        if (serverLevel) {
          if (localUserData.level > serverLevel) {
            seeg.setUserData({
              level: localUserData.level // 同步本地数据到服务器
            });
            cc.log("同步数据：有服务器数据，但比本地数据延迟，同步本地数据给服务器");
          } else if (serverLevel > localUserData.level) {
            localUserData.level = serverLevel; // 更新本地数据为服务器数据
            zqcc_overallSystm.sers().userSrv.setFeibiaoData(localUserData);
            cc.log("同步数据：有服务器数据，切高于本地数据，同步服务器数据给本地");
          } else {
            cc.log("同步数据：不做任何操作"); // 本地与服务器数据相同
          }
        } else {
          seeg.setUserData({
            level: localUserData.level // 服务器无数据，同步本地数据
          });
          cc.log("同步数据：没有服务器数据，同步本地数据给服务器");
        }
      }
      self.zqcc_getRemoteConfig(); // 调用获取远程配置的方法
    });
  };
  _ctor.prototype.zqcc_getRemoteConfig = function () {
    let self = this; // 使用let提高作用域的可控性

    seeg.getGameConfig({
      success(response) {
        cc.log("zqcc_getRemoteConfig", response); // 打印获取的游戏配置
        window.RemoteLevelConfig = response.LevelConfig; // 存储远程级别配置
        self.zqcc_Init(); // 调用初始化方法
      },
      fail() {
        self.zqcc_Init(); // 初始化方法在请求失败时也会被调用
      }
    });
  };
  _ctor.prototype.zqcc_start = function () {
    this.node.getComponent(cc.Canvas).fitHeight = zqcc_userService.default.IPAD;
    this.node.getComponent(cc.Canvas).fitWidth = !zqcc_userService.default.IPAD;
  };
  _ctor.prototype.zqcc_Init = function () {
    return cc__awaiter(this, undefined, undefined, function () {
      let self = this; // 使用let提高作用域的可控性
      return cc__generator(this, function (e) {
        switch (e.label) {
          case 0:
            this.zqcc_totalBar.progress = 0; // 重置进度条
            this.zqcc_onceBar.progress = 0; // 重置一次性进度条
            console.log("加载bundle"); // 打印加载信息
            zqcc_overallSystm.default.InitBundle(); // 初始化bundle
            this.zqcc_totalCnt += zqcc_overallSystm.default.Managers.bundleMgr.getLength(); // 获取并更新总计数
            this.zqcc_totalCnt += this.loadAssetList.length + 1; // 更新总计数，包括加载的资产
            this.zqcc_updateLoadLabel("加载游戏..."); // 更新加载标签
            return [4, zqcc_overallSystm.default.Managers.bundleMgr.loadAllBundle(this.zqcc_updateTotalBar.bind(this))]; // 加载所有bundle
          case 1:
            e.sent(); // 等待加载完成
            return [4, this.zqcc_loadAllFrameAsset()]; // 加载所有帧资产
          case 2:
            e.sent(); // 等待帧资产加载完成
            console.log("-----加载bundle完毕-----"); // 打印加载完结信息
            this.zqcc_loadBeginningScener().then(function (scene) {
              cc.log("+++++loadScene", scene); // 打印加载场景信息
              self.zqcc_updateTotalBar(); // 更新总进度条
              zqcc_overallSystm.default.loadScene(scene); // 加载场景
            }).catch(function () {
              // 处理加载场景时的错误
            });
            return [2]; // 返回结束标识
        }
      });
    });
  };
  _ctor.prototype.zqcc_loadAllFrameAsset = function () {
    let errorInfo;
    let returnInfo;
    return cc__awaiter(this, undefined, undefined, function () {
      let asyncInfo;
      let sendInfo;
      let sendValue;
      let sendErr;
      return cc__generator(this, function (a) {
        switch (a.label) {
          case 0:
            a.trys.push([0, 6, 7, 12]);
            asyncInfo = cc__asyncValues(this.loadAssetList);
            a.label = 1;
          case 1:
            return [4, asyncInfo.next()];
          case 2:
            if ((sendInfo = a.sent()).done) {
              return [3, 5];
            } else {
              sendValue = sendInfo.value;
              this.zqcc_updateLoadLabel(sendValue.name);
              return [4, this.zqcc_loadPreloadAsset(sendValue.bundleKey, sendValue.name)];
            }
          case 3:
            a.sent();
            this.zqcc_updateTotalBar();
            a.label = 4;
          case 4:
            return [3, 1];
          case 5:
            return [3, 12];
          case 6:
            sendErr = a.sent();
            errorInfo = {
              error: sendErr
            };
            return [3, 12];
          case 7:
            a.trys.push([7, , 10, 11]);
            if (sendInfo && !sendInfo.done && (returnInfo = asyncInfo.return)) {
              return [4, returnInfo.call(asyncInfo)];
            } else {
              return [3, 9];
            }
          case 8:
            a.sent();
            a.label = 9;
          case 9:
            return [3, 11];
          case 10:
            if (errorInfo) {
              throw errorInfo.error;
            }
            return [7];
          case 11:
            return [7];
          case 12:
            return [2];
        }
      });
    });
  };
  _ctor.prototype.zqcc_loadPreloadAsset = function (t, e) {
    let context = this; // 使用let提高作用域的可控性

    return new Promise(function (resolve, reject) {
      zqcc_overallSystm.default.Managers.bundleMgr.BundleList[t].preloadDir("preload",
        context.zqcc_updateOnceBar.bind(context), // 绑定上下文
        function (error) { // 处理回调
          if (error) {
            reject(); // 传递错误
            return console.error(e + "---加载失败!!", error); // 打印错误信息
          }
          resolve(); // 成功时解析Promise
        }
      );
    });
  };
  _ctor.prototype.zqcc_loadBeginningScener = function () {
    let context = this; // 使用let提高作用域的可控性

    return new Promise(function () {
      context.zqcc_updateLoadLabel("加载游戏初始场景"); // 更新加载标签

      // 检测 tt 或 wx，并注册 onShow 事件
      (window.tt || window.wx) && (window.tt || window.wx).onShow(function (params) {
        console.log("启动参数如下：", params.query); // 打印启动参数
        console.log("来源信息如下：", params.refererInfo); // 打印来源信息
        console.log("启动场景：", params.scene); // 打印启动场景

        // 检查场景代码并发出事件
        if (!("101001" !== params.scene && "021036" !== params.scene)) {
          window.sceneCode = params.scene;
          zqcc_eventManager.default.emit(cc_GameEventType.EventType.UIEvent.showCheckSceneBtn); // 触发该事件
        }

        // 播放音乐
        if (zqcc_overallSystm.mgrs().soundMgr.isPlayMusic) {
          console.log("播放音乐"); // 打印音乐播放信息
          zqcc_overallSystm.mgrs().soundMgr.playMusic(zqcc_overallSystm.mgrs().soundMgr.shangyige); // 播放音乐
        }
      });

      // 获取用户数据并显示加载界面
      zqcc_overallSystm.sers().userSrv.getFeibiaoData();
      zqcc_overallSystm.sers().uiSrv.showLoding(true, function () {
        zqcc_overallSystm.mgrs().gameMgr.enterMode(cc_gameMode_Json.GAME_MODE.Feibiao, true); // 进入游戏模式
      });
    });
  };
  _ctor.prototype.zqcc_updateTotalBar = function () {
    this.zqcc_completedCnt++; // 增加已完成计数
    this.zqcc_totalBar.progress = this.zqcc_completedCnt / this.zqcc_totalCnt; // 更新总进度条的进度

    // 计算进度条的子节点位置并更新其x坐标
    this.zqcc_totalBar.node.children[0].children[0].x = (this.zqcc_completedCnt / this.zqcc_totalCnt * 567) - 283.5;
  };
  _ctor.prototype.zqcc_updateOnceBar = function (t, e) {
    this.zqcc_onceBar.progress = t / e;
  };
  _ctor.prototype.zqcc_updateLoadLabel = function (t) {
    this.zqcc_lbLoad.string = t;
  };
  _ctor.prototype.update = function () { };
  cc__decorate([cc_ccp_property({
    type: cc.ProgressBar,
    displayName: "整体进度条"
  })], _ctor.prototype, "zqcc_totalBar", undefined);
  cc__decorate([cc_ccp_property({
    type: cc.ProgressBar,
    displayName: "单次进度条"
  })], _ctor.prototype, "zqcc_onceBar", undefined);
  cc__decorate([cc_ccp_property({
    type: cc.Label,
    displayName: "加载文本"
  })], _ctor.prototype, "zqcc_lbLoad", undefined);
  cc__decorate([cc_ccp_property(cc.Node)], _ctor.prototype, "zqcc_tishi", undefined);
  cc__decorate([cc_ccp_property(cc.Node)], _ctor.prototype, "zqcc_kuaishouruanzhu", undefined);
  return cc__decorate([cc_ccp_ccclass], _ctor);
}(cc.Component);
exports.default = def_zqcc_loading;